Eigenvalue problem for radial potentials in space with SU(2) fuzziness

The eigenvalue problem for radial potentials is considered in a space whose spatial coordinates satisfy the SU(2) Lie algebra. As the consequence, the space has a lattice nature and the maximum value of momentum is bounded from above. The model shows interesting features due to the bound, namely, a repulsive potential can develop bound-states, or an attractive region may be forbidden for particles to propagate with higher energies. The exact radial eigen-functions in momentum space are given by means of the associated Chebyshev functions. For the radial stepwise potentials the exact energy condition and the eigen-functions are presented. For a general radial potential it is shown that the discrete energy spectrum can be obtained in desired accuracy by means of given forms of continued fractions.Comment: 1+20 pages, 2 figs, LaTe

Progressive Transactional Memory in Time and Space

Transactional memory (TM) allows concurrent processes to organize sequences of operations on shared \emph{data items} into atomic transactions. A transaction may commit, in which case it appears to have executed sequentially or it may \emph{abort}, in which case no data item is updated. The TM programming paradigm emerged as an alternative to conventional fine-grained locking techniques, offering ease of programming and compositionality. Though typically themselves implemented using locks, TMs hide the inherent issues of lock-based synchronization behind a nice transactional programming interface. In this paper, we explore inherent time and space complexity of lock-based TMs, with a focus of the most popular class of \emph{progressive} lock-based TMs. We derive that a progressive TM might enforce a read-only transaction to perform a quadratic (in the number of the data items it reads) number of steps and access a linear number of distinct memory locations, closing the question of inherent cost of \emph{read validation} in TMs. We then show that the total number of \emph{remote memory references} (RMRs) that take place in an execution of a progressive TM in which $n$ concurrent processes perform transactions on a single data item might reach $\Omega(n \log n)$, which appears to be the first RMR complexity lower bound for transactional memory.Comment: Model of Transactional Memory identical with arXiv:1407.6876, arXiv:1502.0272

On the Optimal Space Complexity of Consensus for Anonymous Processes

The optimal space complexity of consensus in shared memory is a decades-old open problem. For a system of $n$ processes, no algorithm is known that uses a sublinear number of registers. However, the best known lower bound due to Fich, Herlihy, and Shavit requires $\Omega(\sqrt{n})$ registers. The special symmetric case of the problem where processes are anonymous (run the same algorithm) has also attracted attention. Even in this case, the best lower and upper bounds are still $\Omega(\sqrt{n})$ and $O(n)$. Moreover, Fich, Herlihy, and Shavit first proved their lower bound for anonymous processes, and then extended it to the general case. As such, resolving the anonymous case might be a significant step towards understanding and solving the general problem. In this work, we show that in a system of anonymous processes, any consensus algorithm satisfying nondeterministic solo termination has to use $\Omega(n)$ read-write registers in some execution. This implies an $\Omega(n)$ lower bound on the space complexity of deterministic obstruction-free and randomized wait-free consensus, matching the upper bound and closing the symmetric case of the open problem

Monotonic Prefix Consistency in Distributed Systems

We study the issue of data consistency in distributed systems. Specifically, we consider a distributed system that replicates its data at multiple sites, which is prone to partitions, and which is assumed to be available (in the sense that queries are always eventually answered). In such a setting, strong consistency, where all replicas of the system apply synchronously every operation, is not possible to implement. However, many weaker consistency criteria that allow a greater number of behaviors than strong consistency, are implementable in available distributed systems. We focus on determining the strongest consistency criterion that can be implemented in a convergent and available distributed system that tolerates partitions. We focus on objects where the set of operations can be split into updates and queries. We show that no criterion stronger than Monotonic Prefix Consistency (MPC) can be implemented.Comment: Submitted pape

Adaptive gossip-based broadcast

This paper presents a novel adaptation mechanism that allows every node of a gossip-based broadcast algorithm to adjust the rate of message emission 1) to the amount of resources available to the nodes within the same broadcast group and 2) to the global level of congestion in the system. The adaptation mechanism can be applied to all gossip-based broadcast algorithms we know of and makes their use more realistic in practical situations where nodes have limited resources whose quantity changes dynamically with time without decreasing the reliability.(undefined

Distributed programming with typed events

The remote-procedure-call abstraction, including its derivates (underlying, for example, Java RMI, CORBA, and .NET), currently represents one of the most popular paradigms for devising distributed applications. Objects (when acting as servers) are invoked remotely (by clients) through proxies (also called stubs). Because proxies offer the same interfaces as their respective associated remote objects, they hide distribution details, leading to a convenient distributed-programming style that enforces type safety and encapsulation. However, RPC-style interaction does not apply equally well in all contexts. In its classic form, it tends to strongly synchronize-and hence couple-the invoking and invoked objects. Several proposed asynchronous variants of RPC illustrate the severity of this drawback. Type-based publish-subscribe is an appealing candidate programming abstraction for inherently decoupled and completely decentralized applications that run over large-scale and mobile networks. Like RPC, TPS enforces type safety and encapsulation; unlike RPC, it provides decoupling and scalability. To illustrate, we discuss two TPS implementations in Java

Bast, A Framework for Reliable Distributed Computing

Although useful in the development of distributed systems, current reliable distributed environments, such as group communication toolkits (e.g., ISIS, TOTEM, PHOENIX) or transactional monitors (e.g., ENCINA, TUXEDO), are hardly extensible or customisable for specific application needs. The limitations of those systems are mainly due to their underlying distributed protocols, which are usually designed and implemented in an ad hoc manner. This paper presents BAST, an object-oriented framework for building fault-tolerant distributed applications. We also show how BAST is used to implement distributed protocols, by providing centralised and distributed design patterns . In particular, we present how we built atomic commitment and atomic multicast protocols, which provide adequate support for a wide range of fault-tolerant distributed applications. We detail customisation facilities of BAST and discuss our design in the light of different alternatives. Finally, we present BAST implementations in Smalltalk and Java, and we point out some optimisation issues

Democratrizing the Parliament

This paper presents a replication algorithm that implements a highly-available, non-deterministic state machine. Our algorithm generalizes the Paxos parliament algorithm of Lamport to cope with non-deterministic computations, while preserving its nice resilience and efficiency properties. The algorithm is surprisingly simple, thanks to the use of two powerful underlying abstractions: weak consensus and weak leader election, together with a generic data structure: consensus bag. As a side-effect of our work, we discuss some similarities and differences between replicating deterministic and non-deterministic state machines. Indirectly, we revisit the traditional classification between state-machine replication and primary-backup

Robust Emulations of Shared Memory in a Crash-Recovery Model

A shared memory abstraction can be robustly emulated over an asynchronous message passing system where any process can fail by crashing and possibly recover (crash-recovery model), by having (a) the processes exchange messages to synchronize their read and write operations and (b) log key information on their local stable storage. This paper extends the existing atomicity consistency criterion defined for multi-writer/multi-reader shared memory in a crash-stop model, by providing two new criteria for the crash-recovery model. We introduce lower bounds on the log-complexity for each of the two corresponding types of robust shared memory emulations. We demonstrate that our lower bounds are tight by providing algorithms that match them. Besides being optimal, these algorithms have the same message and time complexity as their most efficient counterpart we know of in the crash-stop model